﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Data.Common;
using System.Data;
using Water.Util;

using Water.Architecture2.Model;
using Water.Web.Controls;

namespace Water.Architecture2.IDAL
{
    /// <summary>
    /// 数据库访问的基本接口
    /// </summary>
    /// <typeparam name="T">继承于BaseEntity的数据实体类</typeparam>
    public interface IBaseDAL<T> where T:BaseEntity,new()
    {
        #region === 判断
        /// <summary>
        /// 查询数据库,检查是否存在指定键值的对象
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns>存在则返回<c>true</c>，否则为<c>false</c>。</returns>
        bool IsExist(WhereFields whereFields);
        /// <summary>
        /// 查询数据库,检查是否存在指定键值的对象
        /// </summary>
        /// <param name="fields">Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>存在则返回<c>true</c>，否则为<c>false</c>。</returns>
        bool IsExist(Hashtable fields);
        /// <summary>
        /// 查询数据库,检查是否存在指定键值的对象
        /// </summary>
        /// <param name="fieldName">指定的属性名（字段名）</param>
        /// <param name="fieldValue">指定的值（字段值）</param>
        /// <returns>存在则返回<c>true</c>，否则为<c>false</c>。</returns>
        bool IsExist(string fieldName,object fieldValue);
        /// <summary>
        /// 查询数据库,检查是否存在指定关键字值的对象(只适用于用单主键,用int类型作主键值的表)
        /// </summary>
        /// <param name="id">关键字的值</param>
        /// <returns>存在则返回<c>true</c>，否则为<c>false</c>。</returns>
        bool IsExist(int id);
        #endregion

        #region === 得到单个值
        /// <summary>
        /// 获取数据库中该对象的最大ID值(只适用于用单主键,用int类型作主键值的表)
        /// </summary>
        /// <returns>最大ID值。</returns>
        int GetMaxId();
        /// <summary>
        ///  得到数据库中该对象的总数
        /// </summary>
        /// <returns>数据库中该对象的总数。</returns>
        int GetCount();
        /// <summary>
        /// 得到数据库中该对象的总数
        /// </summary>
        /// <param name="fields">where条件字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>数据库中该对象的总数</returns>
        int GetCount(Hashtable fields);
        /// <summary>
        /// 得到数据库中该对象的总数
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns>数据库中该对象的总数</returns>
        int GetCount(WhereFields whereFields);
        /// <summary>
        /// 得到矩阵查询（行转列）记录总数
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符</param>
        /// <param name="matrixColumnField">显示字段。多字段以","</param>
        /// <param name="groupField">分组字段。转置字段</param>
        /// <param name="valueField">显示值字段</param>
        /// <param name="summaryType">汇总类型</param>
        /// <returns></returns>
        int GetMatrixCount(WhereFields whereFields, string matrixColumnField, string groupField, string valueField, SummaryType summaryType, DataView matrixColumns);
        #endregion

        #region === 对象的添加、删除、修改操作

        #region === 添加
        /// <summary>
        /// 添加一条记录
        /// </summary>
        /// <param name="fields">Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响的行数。</returns>
        int Insert(Hashtable fields, DbTransaction trans);
        /// <summary>
        /// 添加一个对象到数据库中
        /// </summary>
        /// <param name="fields">Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>影响的行数。</returns>
        int Insert(Hashtable fields);

        /// <summary>
        /// 添加一个对象到数据库中
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响的行数。</returns>
        int Insert(T obj, DbTransaction trans);
        /// <summary>
        /// 添加一个对象到数据库中
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <returns>影响的行数。</returns>
        int Insert(T obj);
        
        #endregion

        #region === 删除
     
        /// <summary>
        /// 删除满足给定条件（WhereFields）的记录
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Delete(WhereFields whereFields, DbTransaction trans);
        /// <summary>
        /// 删除满足给定条件（WhereFields）的记录
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns>影响记录的总数</returns>
        int Delete(WhereFields whereFields);
        /// <summary>
        /// 删除一条记录
        /// </summary>
        /// <param name="fields">Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Delete(Hashtable fields, DbTransaction trans);
        /// <summary>
        /// 删除一条记录
        /// </summary>
        /// <param name="fields">Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>影响记录的总数</returns>
        int Delete(Hashtable fields);
        /// <summary>
        /// 删除一条记录(只适用于用单主键,用int类型做主键值的表)
        /// </summary>
        /// <param name="id">主键值</param>
        /// <returns>影响记录的总数</returns>
        int Delete(int id);

        /// <summary>
        /// 从数据库中删除指定对象
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Delete(T obj, DbTransaction trans);
        /// <summary>
        /// 从数据库中删除指定对象
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <returns>影响记录的总数</returns>
        int Delete(T obj);
        #endregion

        #region === 修改
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="updateFields">待更新的字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Update(Hashtable updateFields, WhereFields whereFields, DbTransaction trans);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="updateFields">待更新的字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns>影响记录的总数</returns>
        int Update(Hashtable updateFields, WhereFields whereFields);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="updateFields">待更新的字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="fields">where条件字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Update(Hashtable updateFields, Hashtable fields, DbTransaction trans);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="updateFields">待更新的字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="fields">where条件字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>影响记录的总数</returns>
        int Update(Hashtable updateFields, Hashtable fields);
        /// <summary>
        /// 更新记录(只适用于用单主键,用int类型做主键值的表)
        /// </summary>
        /// <param name="updateFields">待更新的字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="id">主键值</param>
        /// <returns>影响记录的总数</returns>
        int Update(Hashtable updateFields, int id);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Update(T obj, WhereFields whereFields, DbTransaction trans);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns>影响记录的总数</returns>
        int Update(T obj, WhereFields whereFields);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="fields">where条件字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="trans">事务对象,如果使用事务,传入事务对象,否则为Null不使用事务</param>
        /// <returns>影响记录的总数</returns>
        int Update(T obj, Hashtable fields, DbTransaction trans);
        /// <summary>
        /// 更新记录
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="fields">where条件字段，Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>影响记录的总数</returns>
        int Update(T obj, Hashtable fields);
        /// <summary>
        /// 更新记录(只适用于用单主键,用int类型做主键值的表)
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="id">主键值</param>
        /// <returns>影响记录的总数</returns>
        int Update(T obj, int id);
        #endregion

        #endregion

        #region === 数据检索
        #region === 检索所有数据
        /// <summary>
        /// 返回数据库所有的对象集合
        /// </summary>
        /// <returns>检索到的数据库所有的对象集合</returns>
        List<T> GetAll();
        /// <summary>
        /// 以指定的排序表达式,返回数据库所有的对象集合
        /// </summary>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns>检索到的数据库所有的对象集合</returns>
        List<T> GetAll(string sortExpress);
        /// <summary>
        /// 从数据库的所有记录中,返回从指定开始索引行开始返回分页大小的记录对象
        /// </summary>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns>从指定开始索引行开始返回分页大小的记录对象集合</returns>
        List<T> GetAll(int startRowIndex, int pageSize);
        /// <summary>
        /// 以指定的排序表达式从数据库的所有记录中,返回从指定开始索引行开始返回分页大小的记录对象
        /// </summary>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc同SQL的排序表达式</param>
        /// <returns>从指定开始索引行开始返回分页大小的记录对象集合</returns>
        List<T> GetAll(int startRowIndex, int pageSize, string sortExpress);

        /// <summary>
        /// 返回数据库所有的对象集合
        /// </summary>
        /// <returns><c>DataSet</c></returns>
        DataSet GetAllToDataSet();
        /// <summary>
        /// 以指定的排序表达式,返回数据库所有的对象集合
        /// </summary>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DataSet</c></returns>
        DataSet GetAllToDataSet(string sortExpress);
        /// <summary>
        /// 从数据库的所有记录中,返回从指定开始索引行开始返回分页大小的记录
        /// </summary>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns><c>DataSet</c></returns>
        DataSet GetAllToDataSet(int startRowIndex, int pageSize);
        /// <summary>
        /// 以指定的排序表达式从数据库的所有记录中,返回从指定开始索引行开始返回分页大小的记录
        /// </summary>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DataSet</c></returns>
        DataSet GetAllToDataSet(int startRowIndex, int pageSize, string sortExpress);

        /// <summary>
        /// 返回数据库所有的对象集合
        /// </summary>
        /// <returns><c>DbDataReader</c></returns>
        DbDataReader GetAllToDataReader();
        /// <summary>
        /// 以指定的排序表达式,返回数据库所有记录
        /// </summary>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DbDataReader</c></returns>
        DbDataReader GetAllToDataReader(string sortExpress);
        /// <summary>
        /// 从数据库的所有记录中,返回从指定开始索引行开始返回分页大小的记录
        /// </summary>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns><c>DbDataReader</c></returns>
        DbDataReader GetAllToDataReader(int startRowIndex, int pageSize);
        /// <summary>
        /// 以指定的排序表达式从数据库的所有记录中,返回从指定开始索引行开始返回分页大小的记录
        /// </summary>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DbDataReader</c></returns>
        DbDataReader GetAllToDataReader(int startRowIndex, int pageSize, string sortExpress);
        #endregion

        #region === 根据ID检索数据
        /// <summary>
        /// 查询数据库,检查指定ID的对象(只适用于用单主键,用int类型做主键值的表)
        /// </summary>
        /// <param name="id">主键值</param>
        /// <returns>存在则返回指定的对象,否则返回Null</returns>
        T FindByID(int id);
        #endregion

        #region === 根据条件检索
        /// <summary>
        /// 根据条件检索数据库,并返回对象集合
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns>检索到的数据库对象集合</returns>
        List<T> Find(Hashtable fields);
        /// <summary>
        /// 根据条件排序检索数据库,并返回对象集合(有排序功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns>检索到的数据对象集合</returns>
        List<T> Find(Hashtable fields,string sortExpress);
        /// <summary>
        /// 根据条件排序检索数据库,并返回对象集合(有分页功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns>检索到的数据对象集合</returns>
        List<T> Find(Hashtable fields, int startRowIndex, int pageSize);
        /// <summary>
        /// 根据条件排序检索数据库,并返回对象集合(有分页和排序功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns>检索到的数据对象集合</returns>
        List<T> Find(Hashtable fields, int startRowIndex, int pageSize, string sortExpress);



        /// <summary>
        /// 根据条件检索数据库,并返回对象集合
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns>检索到的数据库对象集合</returns>
        List<T> Find(WhereFields whereFields);
        /// <summary>
        /// 根据条件排序检索数据库,并返回对象集合(有排序功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns>检索到的数据对象集合</returns>
        List<T> Find(WhereFields whereFields, string sortExpress);
        /// <summary>
        /// 根据条件排序检索数据库,并返回对象集合(有分页功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns>检索到的数据对象集合</returns>
        List<T> Find(WhereFields whereFields, int startRowIndex, int pageSize);
        /// <summary>
        /// 根据条件排序检索数据库,并返回对象集合(有分页和排序功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns>检索到的数据对象集合</returns>
        List<T> Find(WhereFields whereFields, int startRowIndex, int pageSize, string sortExpress);


        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(Hashtable fields);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有排序功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(Hashtable fields, string sortExpress);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(Hashtable fields, int startRowIndex, int pageSize);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页和排序功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(Hashtable fields, int startRowIndex, int pageSize, string sortExpress);

        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(WhereFields whereFields);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有排序功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(WhereFields whereFields, string sortExpress);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(WhereFields whereFields, int startRowIndex, int pageSize);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页和排序功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>DataSet</c></returns>
        DataSet FindToDataSet(WhereFields whereFields, int startRowIndex, int pageSize, string sortExpress);

        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(Hashtable fields);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有排序功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(Hashtable fields, string sortExpress);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(Hashtable fields, int startRowIndex, int pageSize);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页和排序功能)
        /// </summary>
        /// <param name="fields">检索条件Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(Hashtable fields, int startRowIndex, int pageSize, string sortExpress);


        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(WhereFields whereFields);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有排序功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(WhereFields whereFields, string sortExpress);
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(WhereFields whereFields, int startRowIndex, int pageSize);    
        /// <summary>
        /// 根据条件检索数据库,并返回检索到的记录(有分页和排序功能)
        /// </summary>
        /// <param name="whereFields">where条件字段，WhereFields:Name为字段名,Value为字段对应的值,Operator操作符（SQL逻辑运算符）</param>
        /// <param name="startRowIndex">开始索引行</param>
        /// <param name="pageSize">分页大小</param>
        /// <param name="sortExpress">排序表达式 如：id desc,同SQL的排序表达式</param>
        /// <returns><c>IDataReader</c></returns>
        IDataReader FindToDataReader(WhereFields whereFields, int startRowIndex, int pageSize, string sortExpress);


        IDataReader FindMatrixToDataReader(WhereFields whereFields, string matrixColumnField, string groupField, string valueField, SummaryType summaryType, DataView matrixColumns);

        IDataReader FindMatrixToDataReader(WhereFields whereFields, string sortExpress, string matrixColumnField, string groupField, string valueField, SummaryType summaryType, DataView matrixColumns);

        IDataReader FindMatrixToDataReader(WhereFields whereFields, int startRowIndex, int pageSize, string matrixColumnField, string groupField, string valueField, SummaryType summaryType, DataView matrixColumns);

        IDataReader FindMatrixToDataReader(WhereFields whereFields, int startRowIndex, int pageSize, string sortExpress, string matrixColumnField, string groupField, string valueField, SummaryType summaryType, DataView matrixColumns);

        /// <summary>
        /// 得到矩阵列
        /// </summary>
        /// <param name="whereFields"></param>
        /// <param name="matrixColumnField"></param>
        /// <param name="groupField"></param>
        /// <param name="valueField"></param>
        /// <param name="summaryType"></param>
        /// <returns></returns>
        DataView GetMatrixColumns(WhereFields whereFields, string matrixColumnField, string groupField, string valueField, SummaryType summaryType, string matrixColumnSortExpress);

        #endregion

        #region === 得到自身结构信息
        /// <summary>
        /// 得到自身结构信息(name,column,table,prompt)
        /// </summary>
        /// <returns></returns>
        DataSet GetSelf();
        DataSet GetSelf(WhereFields whereFields);
        #endregion
        #endregion
    }
}
